home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Resources / Online / Term / Extras / Source / term-source.lha / Capture.c < prev    next >
C/C++ Source or Header  |  1996-10-20  |  9KB  |  531 lines
  1. /*
  2. **    Capture.c
  3. **
  4. **    File and printer capture support routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16. STATIC VOID
  17. CaptureCallback1(APTR Buffer,LONG Size)
  18. {
  19.     AddLine(Buffer,Size);
  20.  
  21.     CaptureToFile(Buffer,Size);
  22.     CaptureToFile("\n",1);
  23. }
  24.  
  25. STATIC VOID
  26. CaptureCallback3(APTR Buffer,LONG Size)
  27. {
  28.     AddLine(Buffer,Size);
  29.  
  30.     CaptureToFile(Buffer,Size);
  31.     CaptureToFile("\n",1);
  32.  
  33.     CaptureToPrinter(Buffer,Size);
  34.     CaptureToPrinter("\n",1);
  35. }
  36.  
  37. STATIC VOID
  38. CaptureCallback4(APTR Buffer,LONG Size)
  39. {
  40.     CaptureToFile(Buffer,Size);
  41.     CaptureToFile("\n",1);
  42. }
  43.  
  44. STATIC VOID
  45. CaptureCallback5(APTR Buffer,LONG Size)
  46. {
  47.     CaptureToFile(Buffer,Size);
  48.     CaptureToFile("\n",1);
  49.  
  50.     CaptureToPrinter(Buffer,Size);
  51.     CaptureToPrinter("\n",1);
  52. }
  53.  
  54. STATIC VOID
  55. CaptureCallback6(APTR Buffer,LONG Size)
  56. {
  57.     CaptureToPrinter(Buffer,Size);
  58.     CaptureToPrinter("\n",1);
  59. }
  60.  
  61. STATIC VOID
  62. CaptureCallback7(APTR Buffer,LONG Size)
  63. {
  64.     AddLine(Buffer,Size);
  65.  
  66.     CaptureToPrinter(Buffer,Size);
  67.     CaptureToPrinter("\n",1);
  68. }
  69.  
  70. VOID
  71. CaptureFilteredTo_Buffer(APTR Buffer,LONG Size)
  72. {
  73.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)AddLine);
  74. }
  75.  
  76. VOID
  77. CaptureFilteredTo_Buffer_File(APTR Buffer,LONG Size)
  78. {
  79.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)CaptureCallback1);
  80. }
  81.  
  82. VOID
  83. CaptureFilteredTo_Buffer_File_Printer(APTR Buffer,LONG Size)
  84. {
  85.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)CaptureCallback3);
  86. }
  87.  
  88. VOID
  89. CaptureFilteredTo_File(APTR Buffer,LONG Size)
  90. {
  91.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)CaptureCallback4);
  92. }
  93.  
  94. VOID
  95. CaptureFilteredTo_File_Printer(APTR Buffer,LONG Size)
  96. {
  97.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)CaptureCallback5);
  98. }
  99.  
  100. VOID
  101. CaptureFilteredTo_Printer(APTR Buffer,LONG Size)
  102. {
  103.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)CaptureCallback6);
  104. }
  105.  
  106. VOID
  107. CaptureFilteredTo_Buffer_Printer(APTR Buffer,LONG Size)
  108. {
  109.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)CaptureCallback7);
  110. }
  111.  
  112. VOID
  113. CaptureRawTo_Buffer(APTR Buffer,LONG Size)
  114. {
  115.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)AddLine);
  116. }
  117.  
  118. VOID
  119. CaptureRawTo_Buffer_File(APTR Buffer,LONG Size)
  120. {
  121.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)AddLine);
  122.  
  123.     CaptureToFile(Buffer,Size);
  124. }
  125.  
  126. VOID
  127. CaptureRawTo_Buffer_File_Printer(APTR Buffer,LONG Size)
  128. {
  129.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)AddLine);
  130.  
  131.     CaptureToFile(Buffer,Size);
  132.     CaptureToPrinter(Buffer,Size);
  133. }
  134.  
  135. VOID
  136. CaptureRawTo_Buffer_Printer(APTR Buffer,LONG Size)
  137. {
  138.     CaptureParser(ParserStuff,Buffer,Size,(COPTR)AddLine);
  139.  
  140.     CaptureToPrinter(Buffer,Size);
  141. }
  142.  
  143. VOID
  144. CaptureRawTo_File(APTR Buffer,LONG Size)
  145. {
  146.     CaptureToFile(Buffer,Size);
  147. }
  148.  
  149. VOID
  150. CaptureRawTo_File_Printer(APTR Buffer,LONG Size)
  151. {
  152.     CaptureToFile(Buffer,Size);
  153.     CaptureToPrinter(Buffer,Size);
  154. }
  155.  
  156. VOID
  157. CaptureRawTo_Printer(APTR Buffer,LONG Size)
  158. {
  159.     CaptureToPrinter(Buffer,Size);
  160. }
  161.  
  162.     /* ClosePrinterCapture(BOOL Force):
  163.      *
  164.      *    Closes printer capture file.
  165.      */
  166.  
  167. VOID
  168. ClosePrinterCapture(BOOL Force)
  169. {
  170.     if(PrinterCapture)
  171.     {
  172.         if(ControllerActive && StandardPrinterCapture && !Force)
  173.             FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_TERMINAL_TRANSCRIPT_ENDING_TXT));
  174.  
  175.         if(Force)
  176.         {
  177.             Close(PrinterCapture);
  178.  
  179.             CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  180.  
  181.             PrinterCapture = NULL;
  182.  
  183.             ConOutputUpdate();
  184.  
  185.             StandardPrinterCapture = FALSE;
  186.         }
  187.     }
  188.  
  189.     ControllerActive = FALSE;
  190.  
  191.     ConOutputUpdate();
  192. }
  193.  
  194.     /* OpenPrinterCapture(BOOL Controller):
  195.      *
  196.      *    Opens printer capture file.
  197.      */
  198.  
  199. BOOL
  200. OpenPrinterCapture(BOOL Controller)
  201. {
  202.     if(PrinterCapture)
  203.     {
  204.         if(Controller && !ControllerActive)
  205.         {
  206.             ControllerActive = TRUE;
  207.  
  208.             ConOutputUpdate();
  209.  
  210.             FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_TERMINAL_TRANSCRIPT_FOLLOWS_TXT));
  211.         }
  212.  
  213.         return(TRUE);
  214.     }
  215.     else
  216.     {
  217.         if(PrinterCapture = Open("PRT:",MODE_NEWFILE))
  218.             CheckItem(MEN_CAPTURE_TO_PRINTER,TRUE);
  219.         else
  220.         {
  221.             CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  222.  
  223.             BlockWindows();
  224.  
  225.             ShowRequest(Window,LocaleString(MSG_TERMMAIN_ERROR_OPENING_PRINTER_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),"PRT:");
  226.  
  227.             ReleaseWindows();
  228.         }
  229.  
  230.         if(Controller)
  231.         {
  232.             ControllerActive        = TRUE;
  233.             StandardPrinterCapture    = FALSE;
  234.         }
  235.         else
  236.         {
  237.             StandardPrinterCapture = FALSE;
  238.  
  239.             if(ControllerActive)
  240.                 FPrintf(PrinterCapture,LocaleString(MSG_CONSOLE_USER_TERMINAL_TRANSCRIPT_FOLLOWS_TXT));
  241.         }
  242.  
  243.         ConOutputUpdate();
  244.  
  245.         if(PrinterCapture)
  246.             return(TRUE);
  247.         else
  248.             return(FALSE);
  249.     }
  250. }
  251.  
  252.     /* CloseFileCapture():
  253.      *
  254.      *    Close the capture file.
  255.      */
  256.  
  257. VOID
  258. CloseFileCapture()
  259. {
  260.     if(FileCapture)
  261.     {
  262.         BufferClose(FileCapture);
  263.  
  264.         FileCapture = NULL;
  265.  
  266.         if(!GetFileSize(CaptureName))
  267.             DeleteFile(CaptureName);
  268.         else
  269.         {
  270.             AddProtection(CaptureName,FIBF_EXECUTE);
  271.  
  272.             if(Config->MiscConfig->CreateIcons)
  273.                 AddIcon(CaptureName,FILETYPE_TEXT,FALSE);
  274.         }
  275.     }
  276.  
  277.     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  278.     CheckItem(MEN_CAPTURE_TO_RAW_FILE,FALSE);
  279.  
  280.     RawCapture = FALSE;
  281.  
  282.     ConOutputUpdate();
  283. }
  284.  
  285.     /* OpenFileCapture():
  286.      *
  287.      *    Open a capture file.
  288.      */
  289.  
  290. BOOL
  291. OpenFileCapture(BOOL Raw)
  292. {
  293.     UBYTE DummyBuffer[MAX_FILENAME_LENGTH];
  294.     struct FileRequester *FileRequest;
  295.     BOOL Aborted;
  296.  
  297.     Aborted = FALSE;
  298.  
  299.     CloseFileCapture();
  300.  
  301.     BlockWindows();
  302.  
  303.     if(!CaptureName[0])
  304.     {
  305.         strcpy(CaptureName,Config->CaptureConfig->CapturePath);
  306.  
  307.         if(!AddPart(CaptureName,LocaleString(MSG_DIALPANEL_CAPTURE_NAME_TXT),sizeof(CaptureName)))
  308.             CaptureName[0] = 0;
  309.     }
  310.  
  311.     strcpy(DummyBuffer,CaptureName);
  312.  
  313.     if(FileRequest = SaveFile(Window,LocaleString(MSG_TERMMAIN_CAPTURE_TO_DISK_TXT),NULL,NULL,DummyBuffer,sizeof(DummyBuffer)))
  314.     {
  315.         FreeAslRequest(FileRequest);
  316.  
  317.         if(GetFileSize(DummyBuffer))
  318.         {
  319.             switch(ShowRequest(Window,LocaleString(MSG_GLOBAL_FILE_ALREADY_EXISTS_TXT),LocaleString(MSG_GLOBAL_CREATE_APPEND_CANCEL_TXT),DummyBuffer))
  320.             {
  321.                 case 0:
  322.  
  323.                     FileCapture = NULL;
  324.  
  325.                     Aborted = TRUE;
  326.  
  327.                     break;
  328.  
  329.                 case 1:
  330.  
  331.                     FileCapture = BufferOpen(DummyBuffer,"w");
  332.                     break;
  333.  
  334.                 case 2:
  335.  
  336.                     FileCapture = BufferOpen(DummyBuffer,"a");
  337.                     break;
  338.             }
  339.         }
  340.         else
  341.             FileCapture = BufferOpen(DummyBuffer,"w");
  342.  
  343.         if(!Aborted)
  344.         {
  345.             if(!FileCapture)
  346.                 ShowError(Window,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  347.             else
  348.                 strcpy(CaptureName,DummyBuffer);
  349.         }
  350.     }
  351.  
  352.     if(Raw)
  353.     {
  354.         if(FileCapture)
  355.             CheckItem(MEN_CAPTURE_TO_RAW_FILE,TRUE);
  356.         else
  357.             CheckItem(MEN_CAPTURE_TO_RAW_FILE,FALSE);
  358.  
  359.         RawCapture = TRUE;
  360.     }
  361.     else
  362.     {
  363.         if(FileCapture)
  364.             CheckItem(MEN_CAPTURE_TO_FILE,TRUE);
  365.         else
  366.             CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  367.  
  368.         RawCapture = FALSE;
  369.     }
  370.  
  371.     ConOutputUpdate();
  372.  
  373.     ReleaseWindows();
  374.  
  375.     if(FileCapture)
  376.         return(TRUE);
  377.     else
  378.         return(FALSE);
  379. }
  380.  
  381.     /* CaptureToFile(APTR Buffer,LONG Size):
  382.      *
  383.      *    Send data to the capture file.
  384.      */
  385.  
  386. VOID
  387. CaptureToFile(APTR Buffer,LONG Size)
  388. {
  389.     if(Size)
  390.     {
  391.         if(BufferWrite(FileCapture,Buffer,Size) != Size)
  392.         {
  393.             BlockWindows();
  394.  
  395.                 /* We had an error writing to the file. */
  396.  
  397.             switch(ShowRequest(NULL,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_CAPTURE_FILE_TXT),LocaleString(MSG_CONSOLE_IGNORE_DISCARD_CLOSE_TXT),CaptureName))
  398.             {
  399.                 case 1:
  400.  
  401.                     BufferClose(FileCapture);
  402.  
  403.                     DeleteFile(CaptureName);
  404.  
  405.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  406.  
  407.                     FileCapture = NULL;
  408.  
  409.                     ConOutputUpdate();
  410.  
  411.                     break;
  412.  
  413.                 case 2:
  414.  
  415.                     BufferClose(FileCapture);
  416.  
  417.                     CheckItem(MEN_CAPTURE_TO_FILE,FALSE);
  418.  
  419.                     FileCapture = NULL;
  420.  
  421.                     if(!GetFileSize(CaptureName))
  422.                         DeleteFile(CaptureName);
  423.                     else
  424.                     {
  425.                         AddProtection(CaptureName,FIBF_EXECUTE);
  426.  
  427.                         if(Config->MiscConfig->CreateIcons)
  428.                             AddIcon(CaptureName,FILETYPE_TEXT,FALSE);
  429.                     }
  430.  
  431.                     ConOutputUpdate();
  432.  
  433.                     break;
  434.             }
  435.  
  436.             ReleaseWindows();
  437.         }
  438.     }
  439. }
  440.  
  441.     /* CaptureToPrinter(APTR Buffer,LONG Size):
  442.      *
  443.      *    Send capture data to the printer, convert the
  444.      *    characters as necessary to avoid shocking the
  445.      *    printer.
  446.      */
  447.  
  448. VOID
  449. CaptureToPrinter(APTR Buffer,LONG Size)
  450. {
  451.     if(!Config->CaptureConfig->ConvertChars && Config->TerminalConfig->FontMode != FONT_STANDARD)
  452.     {
  453.         UBYTE  LocalBuffer[BUFFER_LINE_MAX];
  454.         UBYTE *Src,*Dst,c;
  455.         ULONG Count;
  456.  
  457.         Src = Buffer;
  458.  
  459.         while(Size > 0)
  460.         {
  461.             Count = MIN(Size,BUFFER_LINE_MAX);
  462.  
  463.             Size -= Count;
  464.  
  465.             Dst = LocalBuffer;
  466.  
  467.             do
  468.             {
  469.                 if(c = ISOConversion[*Src++])
  470.                     *Dst++ = c;
  471.                 else
  472.                     *Dst++ = ' ';
  473.             }
  474.             while(--Count > 0);
  475.  
  476.             Count = (ULONG)Dst - (ULONG)&LocalBuffer[0];
  477.  
  478.             while(Count > 0 && LocalBuffer[Count - 1] == ' ')
  479.                 Count--;
  480.  
  481.             if(Count > 0)
  482.             {
  483.                 if(Write(PrinterCapture,LocalBuffer,Count) != Count)
  484.                 {
  485.                     BlockWindows();
  486.  
  487.                     if(!ShowRequest(Window,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
  488.                     {
  489.                         Close(PrinterCapture);
  490.  
  491.                         CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  492.  
  493.                         PrinterCapture = NULL;
  494.  
  495.                         ConOutputUpdate();
  496.  
  497.                         Size = 0;
  498.                     }
  499.  
  500.                     ReleaseWindows();
  501.                 }
  502.             }
  503.         }
  504.     }
  505.     else
  506.     {
  507.         if(Size > 0)
  508.         {
  509.                 /* Send the buffer to the printer. */
  510.  
  511.             if(Write(PrinterCapture,Buffer,Size) != Size)
  512.             {
  513.                 BlockWindows();
  514.  
  515.                 if(!ShowRequest(Window,LocaleString(MSG_CONSOLE_ERROR_WRITING_TO_PRINTER_TXT),LocaleString(MSG_CONSOLE_IGNORE_CLOSE_PRINTER_TXT)))
  516.                 {
  517.                     Close(PrinterCapture);
  518.  
  519.                     CheckItem(MEN_CAPTURE_TO_PRINTER,FALSE);
  520.  
  521.                     PrinterCapture = NULL;
  522.  
  523.                     ConOutputUpdate();
  524.                 }
  525.  
  526.                 ReleaseWindows();
  527.             }
  528.         }
  529.     }
  530. }
  531.